/*
 * Copyright (c) 1996, 2000, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

/*
 * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
 * (C) Copyright IBM Corp. 1996, 1997 - All Rights Reserved
 *
 *   The original version of this source code and documentation is copyrighted
 * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
 * materials are provided under terms of a License Agreement between Taligent
 * and Sun. This technology is protected by multiple US and International
 * patents. This notice and attribution to Taligent may not be removed.
 *   Taligent is a registered trademark of Taligent, Inc.
 *
 */

package java.text;

import java.lang.Character;

/**
 * Utility class for normalizing and merging patterns for collation.
 * This is to be used with MergeCollation for adding patterns to an
 * existing rule table.
 * @see        MergeCollation
 * @author     Mark Davis, Helena Shih
 */

class PatternEntry {
    /**
     * Gets the current extension, quoted
     */
    public void appendQuotedExtension(StringBuffer toAddTo) {
        appendQuoted(extension, toAddTo);
    }

    /**
     * Gets the current chars, quoted
     */
    public void appendQuotedChars(StringBuffer toAddTo) {
        appendQuoted(chars, toAddTo);
    }

    /**
     * WARNING this is used for searching in a Vector.
     * Because Vector.indexOf doesn't take a comparator,
     * this method is ill-defined and ignores strength.
     */
    public boolean equals(Object obj) {
        if (obj == null)
            return false;
        PatternEntry other = (PatternEntry) obj;
        boolean result = chars.equals(other.chars);
        return result;
    }

    public int hashCode() {
        return chars.hashCode();
    }

    /**
     * For debugging.
     */
    public String toString() {
        StringBuffer result = new StringBuffer();
        addToBuffer(result, true, false, null);
        return result.toString();
    }

    /**
     * Gets the strength of the entry.
     */
    final int getStrength() {
        return strength;
    }

    /**
     * Gets the expanding characters of the entry.
     */
    final String getExtension() {
        return extension;
    }

    /**
     * Gets the core characters of the entry.
     */
    final String getChars() {
        return chars;
    }

    // ===== privates =====

    void addToBuffer(StringBuffer toAddTo, boolean showExtension, boolean showWhiteSpace, PatternEntry lastEntry) {
        if (showWhiteSpace && toAddTo.length() > 0)
            if (strength == Collator.PRIMARY || lastEntry != null)
                toAddTo.append('\n');
            else
                toAddTo.append(' ');
        if (lastEntry != null) {
            toAddTo.append('&');
            if (showWhiteSpace)
                toAddTo.append(' ');
            lastEntry.appendQuotedChars(toAddTo);
            appendQuotedExtension(toAddTo);
            if (showWhiteSpace)
                toAddTo.append(' ');
        }
        switch (strength) {
            case Collator.IDENTICAL:
                toAddTo.append('=');
                break;
            case Collator.TERTIARY:
                toAddTo.append(',');
                break;
            case Collator.SECONDARY:
                toAddTo.append(';');
                break;
            case Collator.PRIMARY:
                toAddTo.append('<');
                break;
            case RESET:
                toAddTo.append('&');
                break;
            case UNSET:
                toAddTo.append('?');
                break;
        }
        if (showWhiteSpace)
            toAddTo.append(' ');
        appendQuoted(chars, toAddTo);
        if (showExtension && extension.length() != 0) {
            toAddTo.append('/');
            appendQuoted(extension, toAddTo);
        }
    }

    static void appendQuoted(String chars, StringBuffer toAddTo) {
        boolean inQuote = false;
        char ch = chars.charAt(0);
        if (Character.isSpaceChar(ch)) {
            inQuote = true;
            toAddTo.append('\'');
        } else {
            if (PatternEntry.isSpecialChar(ch)) {
                inQuote = true;
                toAddTo.append('\'');
            } else {
                switch (ch) {
                    case 0x0010:
                    case '\f':
                    case '\r':
                    case '\t':
                    case '\n':
                    case '@':
                        inQuote = true;
                        toAddTo.append('\'');
                        break;
                    case '\'':
                        inQuote = true;
                        toAddTo.append('\'');
                        break;
                    default:
                        if (inQuote) {
                            inQuote = false;
                            toAddTo.append('\'');
                        }
                        break;
                }
            }
        }
        toAddTo.append(chars);
        if (inQuote)
            toAddTo.append('\'');
    }

    //========================================================================
    // Parsing a pattern into a list of PatternEntries....
    //========================================================================

    PatternEntry(int strength, StringBuffer chars, StringBuffer extension) {
        this.strength = strength;
        this.chars = chars.toString();
        this.extension = (extension.length() > 0) ? extension.toString() : "";
    }

    static class Parser {
        private String pattern;
        private int i;

        public Parser(String pattern) {
            this.pattern = pattern;
            this.i = 0;
        }

        public PatternEntry next() throws ParseException {
            int newStrength = UNSET;

            newChars.setLength(0);
            newExtension.setLength(0);

            boolean inChars = true;
            boolean inQuote = false;
            mainLoop: while (i < pattern.length()) {
                char ch = pattern.charAt(i);
                if (inQuote) {
                    if (ch == '\'') {
                        inQuote = false;
                    } else {
                        if (newChars.length() == 0)
                            newChars.append(ch);
                        else if (inChars)
                            newChars.append(ch);
                        else
                            newExtension.append(ch);
                    }
                } else
                    switch (ch) {
                        case '=':
                            if (newStrength != UNSET)
                                break mainLoop;
                            newStrength = Collator.IDENTICAL;
                            break;
                        case ',':
                            if (newStrength != UNSET)
                                break mainLoop;
                            newStrength = Collator.TERTIARY;
                            break;
                        case ';':
                            if (newStrength != UNSET)
                                break mainLoop;
                            newStrength = Collator.SECONDARY;
                            break;
                        case '<':
                            if (newStrength != UNSET)
                                break mainLoop;
                            newStrength = Collator.PRIMARY;
                            break;
                        case '&':
                            if (newStrength != UNSET)
                                break mainLoop;
                            newStrength = RESET;
                            break;
                        case '\t':
                        case '\n':
                        case '\f':
                        case '\r':
                        case ' ':
                            break; // skip whitespace TODO use Character
                        case '/':
                            inChars = false;
                            break;
                        case '\'':
                            inQuote = true;
                            ch = pattern.charAt(++i);
                            if (newChars.length() == 0)
                                newChars.append(ch);
                            else if (inChars)
                                newChars.append(ch);
                            else
                                newExtension.append(ch);
                            break;
                        default:
                            if (newStrength == UNSET) {
                                throw new ParseException("missing char (=,;<&) : " + pattern.substring(i, (i + 10 < pattern.length()) ? i + 10 : pattern.length()), i);
                            }
                            if (PatternEntry.isSpecialChar(ch) && (inQuote == false))
                                throw new ParseException("Unquoted punctuation character : " + Integer.toString(ch, 16), i);
                            if (inChars) {
                                newChars.append(ch);
                            } else {
                                newExtension.append(ch);
                            }
                            break;
                    }
                i++;
            }
            if (newStrength == UNSET)
                return null;
            if (newChars.length() == 0) {
                throw new ParseException("missing chars (=,;<&): " + pattern.substring(i, (i + 10 < pattern.length()) ? i + 10 : pattern.length()), i);
            }

            return new PatternEntry(newStrength, newChars, newExtension);
        }

        // We re-use these objects in order to improve performance
        private StringBuffer newChars = new StringBuffer();
        private StringBuffer newExtension = new StringBuffer();

    }

    static boolean isSpecialChar(char ch) {
        return ((ch == '\u0020') || ((ch <= '\u002F') && (ch >= '\u0022')) || ((ch <= '\u003F') && (ch >= '\u003A')) || ((ch <= '\u0060') && (ch >= '\u005B')) || ((ch <= '\u007E') && (ch >= '\u007B')));
    }

    static final int RESET = -2;
    static final int UNSET = -1;

    int strength = UNSET;
    String chars = "";
    String extension = "";
}
